home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 388_01 / ae / 93 / jul / command.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-17  |  8.2 KB  |  503 lines
  1. /*
  2.  * command.c        
  3.  *
  4.  * Anthony's Editor July 93
  5.  *
  6.  * Copyright 1993, 1993 by Anthony Howe.  All rights reserved.  No warranty.
  7.  */
  8.  
  9. #include <ctype.h>
  10. #include "header.h"
  11.  
  12. void prt_macros _((void));
  13. int yesno _((int));
  14. int more _((int));
  15. void prompt _((t_msg, char *, size_t));
  16.  
  17. void
  18. top()
  19. {
  20.     point = 0;
  21. }
  22.  
  23. void
  24. bottom()
  25. {
  26.     epage = point = pos(ebuf);
  27. }
  28.  
  29. void
  30. quit_ask()
  31. {
  32.     if (modified) {
  33.         standout();
  34.         mvaddstr(MSGLINE, 0, getmsg(p_notsaved));
  35.         standend();
  36.         clrtoeol();
  37.         if (!yesno(FALSE))
  38.             return;
  39.     }
  40.     quit();
  41. }
  42.  
  43. int
  44. yesno(flag)
  45. int flag;
  46. {
  47.     int ch;
  48.  
  49.     addstr(getmsg(flag ? p_yes : p_no));
  50.     refresh();
  51.     ch = getliteral();
  52.     if (ch == '\r' || ch == '\n')
  53.         return (flag);
  54.     return (ch == getmsg(p_yes)[1]);
  55. }
  56.  
  57. void
  58. quit()
  59. {
  60.     done = 1;
  61. }
  62.  
  63. void
  64. redraw()
  65. {
  66.     int col;
  67.  
  68.     clear();
  69.     if (textline != HELPLINE) {
  70.         move(HELPLINE, 0);
  71.         addstr(getmsg(m_help));
  72.         ruler(COLS);
  73.         getyx(stdscr, textline, col);
  74.     }
  75.     display(dispfull);
  76. }
  77.  
  78. void
  79. left()
  80. {
  81.     if (0 < point && iscrlf(--point) == 2)
  82.         --point;
  83. } 
  84.  
  85. void
  86. right()
  87. {
  88.     if (point < pos(ebuf) && iscrlf(point++) == 1)
  89.         ++point;
  90. }
  91.  
  92. void
  93. up()
  94. {
  95.     point = lncolumn(upup(point), col);
  96.     if (iscrlf(point) == 2)
  97.         --point;
  98. }
  99.  
  100. void
  101. down()
  102. {
  103.     point = lncolumn(dndn(point), col);
  104.     if (iscrlf(point) == 2)
  105.         --point;
  106. }
  107.  
  108. void
  109. lnbegin()
  110. {
  111.     point = segstart(lnstart(point), point);
  112. }
  113.  
  114. void
  115. lnend()
  116. {
  117.     point = dndn(point);
  118.     left();
  119. }
  120.  
  121. void
  122. wleft()
  123. {
  124.     while (!isalnum(*ptr(--point)) && 0 < point)
  125.         ;
  126.     while (isalnum(*ptr(--point)) && 0 <= point)
  127.         ;
  128.     ++point;
  129. }
  130.  
  131. void
  132. wright()
  133. {
  134.     t_point epoint = pos(ebuf);
  135.     while (isalnum(*ptr(point)) && point < epoint)
  136.         ++point;
  137.     while (!isalnum(*ptr(point)) && point < epoint) 
  138.         ++point;
  139. }
  140.  
  141. void
  142. pgdown()
  143. {
  144.     page = point = upup(epage);
  145.     while (textline < row--)
  146.         down();
  147.     epage = pos(ebuf);
  148. }
  149.  
  150. void
  151. pgup()
  152. {
  153.     int i = LINES;
  154.     while (textline < --i) {
  155.         page = upup(page);
  156.         up();
  157.     }
  158. }
  159.  
  160. void
  161. insert()
  162. {
  163.     assert(gap <= egap);
  164.     if (gap == egap && !growgap(CHUNK))
  165.         return;
  166.     point = movegap(point);
  167.     *gap++ = input == K_LITERAL ? getliteral() : input;
  168.     if (input == '\r' && (gap < egap || growgap(CHUNK)))
  169.         *gap++ = '\n';
  170.     modified = TRUE;
  171.     point = pos(egap);
  172. }
  173.  
  174. void
  175. insert_mode()
  176. {
  177.     int ch;
  178.     t_point opoint;
  179.     point = opoint = movegap(point);
  180.     undoset();
  181.     while ((ch = getkey(key_mode)) != K_INSERT_EXIT) {
  182.         if (ch == K_STTY_ERASE) {
  183.             if (opoint < point) {
  184.                 if (*--gap == '\n' 
  185.                 && buf < gap && gap[-1] == '\r')
  186.                     --gap;
  187.                 modified = TRUE;
  188.             }
  189.         } else {
  190.             assert(gap <= egap);
  191.             if (gap == egap && !growgap(CHUNK)) 
  192.                 break;
  193.             *gap++ = ch == K_LITERAL ? getliteral() : ch;
  194.             if (ch == '\r' && (gap < egap || growgap(CHUNK)))
  195.                 *gap++ = '\n';
  196.             modified = TRUE;
  197.         }
  198.         point = pos(egap);
  199.         display(dispfull);
  200.     }
  201. }
  202.  
  203. void
  204. backsp()
  205. {
  206.     point = movegap(point);
  207.     undoset();
  208.     if (buf < gap) {
  209.         if (*--gap == '\n' && buf < gap && gap[-1] == '\r')
  210.             --gap;
  211.         point = pos(egap);
  212.         modified = TRUE;
  213.     }
  214. }
  215.  
  216. void
  217. delete()
  218. {
  219.     point = movegap(point);
  220.     undoset();
  221.     if (egap < ebuf) {
  222.         if (*egap++ == '\r' && egap < ebuf && *egap == '\n')
  223.             ++egap;
  224.         point = pos(egap);
  225.         modified = TRUE;
  226.     }
  227. }
  228.  
  229. void
  230. readfile()
  231. {
  232.     temp[0] = '\0';
  233.     prompt(p_read, temp, BUFSIZ);
  234.     (void) load(temp);
  235.     if (filename[0] == '\0') {
  236.         strcpy(filename, temp);
  237.         modified = FALSE;
  238.     }
  239. }
  240.  
  241. void
  242. writefile()
  243. {
  244.     standout();
  245.     if (marker == NOMARK || point == marker) {
  246.         strcpy(temp, filename);
  247.         prompt(p_write, temp, BUFSIZ);
  248.     } else {
  249.         temp[0] = '\0';
  250.         prompt(p_bwrite, temp, BUFSIZ);
  251.     }
  252.     (void) save(temp);
  253.     if (marker == NOMARK && filename[0] == '\0') 
  254.         strcpy(filename, temp);
  255. }
  256.  
  257. void
  258. help()
  259. {
  260.     textline = textline == HELPLINE ? -1 : HELPLINE;
  261.     /* When textline != HELPLINE, then redraw() will compute the 
  262.      * actual textline that follows the help text.
  263.      */
  264.     redraw();
  265. }
  266.  
  267. void
  268. block()
  269. {
  270.     marker = marker == NOMARK ? point : NOMARK;
  271. }
  272.  
  273. void
  274. cut()
  275. {
  276.     if (marker == NOMARK || point == marker)
  277.         return;
  278.     if (scrap != NULL) {
  279.         free(scrap);
  280.         scrap = NULL;
  281.     }
  282.     if (point < marker) {
  283.         (void) movegap(point);
  284.         nscrap = marker - point;
  285.     } else {
  286.         (void) movegap(marker);
  287.         nscrap = point - marker;
  288.     }
  289.     if ((scrap = (t_char*) malloc(nscrap)) == NULL) {
  290.         msg(m_alloc);
  291.     } else {
  292.         undoset();
  293.         (void) memcpy(scrap, egap, nscrap * sizeof (t_char));
  294.         egap += nscrap;
  295.         block();
  296.         point = pos(egap);
  297.         modified = TRUE;
  298.     }
  299. }
  300.  
  301. void
  302. paste()
  303. {
  304.     if (nscrap <= 0) {
  305.         msg(m_scrap);
  306.     } else if (nscrap < egap-gap || growgap(nscrap)) {
  307.         point = movegap(point);
  308.         undoset();
  309.         memcpy(gap, scrap, nscrap * sizeof (t_char));
  310.         gap += nscrap;
  311.         point = pos(egap);
  312.         modified = TRUE;
  313.     }
  314. }
  315.  
  316. void
  317. version()
  318. {
  319.     msg(m_version);
  320. }
  321.  
  322. void
  323. macro()
  324. {
  325.     t_keymap *kp;
  326.     size_t buflen, rhsoff;
  327.     char *buf, *lhs, *rhs;
  328.  
  329.     if ((buf = (char *) malloc(BUFSIZ)) == NULL) {
  330.         msg(m_alloc);
  331.         return;
  332.     }
  333.     buf[0] = '\0';
  334.     prompt(p_macro, buf, BUFSIZ);
  335.     buflen = strlen(buf)+1;
  336.  
  337.     if ((lhs = strtok(buf, " \t")) == NULL) {
  338.         prt_macros();
  339.     } else if (buf < lhs) {
  340.         /* Ideally we should shuffle the buffer down so that
  341.          * the lhs starts at the beginning of buffer.
  342.          */
  343.         msg(m_error);
  344.     } else if (encode(lhs) < 0) {
  345.         msg(m_badescape);
  346.     } else {
  347.         kp = findkey(key_map, lhs);
  348.         if ((rhs = strtok(NULL, " \t")) == NULL) {
  349.             /* Delete macro. */
  350.             if (kp == NULL || kp->code != K_MACRO_DEFINE) {
  351.                 msg(m_nomacro);
  352.             } else {
  353.                 free(kp->lhs);
  354.                 kp->lhs = kp->rhs = NULL;
  355.             }
  356.         } else if (encode(rhs) < 0) { 
  357.             msg(m_badescape);
  358.         } else {
  359.             rhsoff = (size_t)(rhs - buf);
  360.             if ((buf = (char *) realloc(buf, buflen)) == NULL) {
  361.                 free(buf);
  362.                 msg(m_alloc);
  363.                 return;
  364.             }
  365.  
  366.             if (kp == NULL) {
  367.                 /* Find free slot to add macro. */
  368.                 for (kp = key_map; kp->code != K_ERROR; ++kp) {
  369.                     if (kp->code == K_MACRO_DEFINE
  370.                     && kp->lhs == NULL)
  371.                         break;
  372.                 }
  373.             }
  374.             if (kp->code == K_ERROR) {
  375.                 msg(m_slots);
  376.             } else if (kp->code == K_MACRO_DEFINE) {
  377.                 /* Change macro. */
  378.                 kp->lhs = buf;
  379.                 kp->rhs = buf + rhsoff;
  380.                 return;
  381.             } else {
  382.                 msg(m_nomacro);
  383.             }
  384.         }
  385.     }
  386.     free(buf);
  387. }
  388.  
  389. void
  390. prt_macros()
  391. {
  392.     t_keymap *kp;
  393.     int used, total;
  394.     unsigned char *ptr;
  395.  
  396.     erase();
  397.     scrollok(stdscr, TRUE);
  398.     for (used = total = 0, kp = key_map; kp->code != K_ERROR; ++kp) {
  399.         if (kp->code == K_MACRO_DEFINE) {
  400.             ++total;
  401.             if (kp->rhs != NULL) {
  402.                 ++used;
  403.                 addch('{');
  404.                 ptr = (unsigned char *) kp->lhs; 
  405.                 for (; *ptr != '\0'; ++ptr) 
  406.                     addstr(printable(*ptr));
  407.                 addstr("}\t{");
  408.                 ptr = (unsigned char *) kp->rhs; 
  409.                 for (; *ptr != '\0'; ++ptr) 
  410.                     addstr(printable(*ptr));
  411.                 addstr("}\n");
  412.                 (void) more(used);
  413.             }
  414.         }
  415.     }
  416.     printw("\n%d/%d\n", used, total);
  417.     scrollok(stdscr, FALSE);
  418.     (void) more(-1);
  419.     redraw();
  420. }
  421.  
  422. /*
  423.  * Return true if more should continue.
  424.  */
  425. int
  426. more(row)
  427. int row;
  428. {
  429.     int ch;
  430.  
  431.     if (0 < row % (LINES-1))
  432.         return (TRUE);
  433.     standout();
  434.     addstr(getmsg(p_more));
  435.     standend();
  436.     clrtoeol();
  437.     refresh();
  438.     ch = getliteral();
  439.     addch('\r');
  440.     clrtoeol();
  441.     return (ch != getmsg(p_quit)[1] && ch != getmsg(p_no)[1]);
  442. }
  443.  
  444. /*
  445.  * Flip the case of a region.  
  446.  */
  447. void
  448. flipcase()
  449. {
  450.     t_char *p;
  451.     t_region r;
  452.     for (getregion(&r); r.left <= r.right; ++r.left) {
  453.         p = ptr(r.left);
  454.         if (islower(*p)) {
  455.             *p = toupper(*p);
  456.             modified = TRUE;
  457.         } else if (isupper(*p)) {
  458.             *p = tolower(*p);
  459.             modified = TRUE;
  460.         }
  461.     }
  462.     if (marker == NOMARK)
  463.         right();
  464. }
  465.  
  466. void
  467. prompt(m, buf, len)
  468. t_msg m;
  469. char *buf;
  470. size_t len;
  471. {
  472.     standout();
  473.     mvaddstr(MSGLINE, 0, getmsg(m));
  474.     standend();
  475.     clrtoeol();
  476.     addch(' ');
  477.     refresh();
  478.     getinput(buf, len, TRUE);
  479. }
  480.  
  481. /*
  482.  * Return 1 if offset points to first-half of CR-LF; 
  483.  * 2 if offset points to second-half of CR-LF; 0 otherwise.
  484.  */
  485. int
  486. iscrlf(offset)
  487. register t_point offset;
  488. {
  489.     register t_char *p;
  490.  
  491.     p = ptr(offset);
  492.     if (*p == '\r') {
  493.         /* Look to the right for '\n'. */
  494.         if (++offset < pos(ebuf) && *ptr(offset) == '\n')
  495.             return (1);
  496.     } else if (*p == '\n') {
  497.         /* Look to the left for '\r'. */
  498.         if (pos(buf) < offset && *ptr(--offset) == '\r')
  499.             return (2);
  500.     }
  501.     return (0);
  502. }
  503.